CocoBase(tm) You thought it, THOUGHT Inc made it!

You thought it, made it!

The Premier Purveyor of Powerful Programming Tools Exclusively for the Java Developer.

The Java(tm) Client Server Solution!

CocoBase(tm) - A White Paper

Although many systems exist to provide Relational Access to Object Oriented Applications, most only address enough of them to deliver on the 'cost savings' and 'reusability' promised by the 'Client/Server Revolution' as it has often been dubbed. Issues range from how to bridge the two conflicting paradigms of Object and Relational technology to how do we manage the dynamic changes of modern application development and an often shifting requirements list, both in terms of Relational changes, and Client side changes.

CocoBase(tm) is a new family of software products designed to address the problems of the Relational to Object bridge, as well as the goals of modern IS/IT organizations to develop, deploy and re-deploy rapidly, efficiently and inexpensively. It also comes to terms with issues of migrating from two-tier to three-tier deployment easily and inexpensively.

Components:

CocoBase(tm) is comprised of two standard components, as well as add on three-tier components. The two primary components are collectively known as the CocoMass(tm) product and are individually called CocoPowder(tm) and CocoButter(tm). CocoPowder(tm) provides for transparent runtime Object to Relational Mapping in Java Applications. CocoButter(tm) is a separate GUI based administration tool which creates and manages Object Schema.

CocoMass(tm) - The core CocoBase(tm) Product.

The CocoMass(tm) - CocoPowder(tm) Component:

CocoPowder(tm) provides a powerful abstraction layer with a deceptively simple user interface. It allows for Objects to be dynamically and transparently be translated to and from a Relational Database. It supports basic database oriented functionality including 'select', 'insert', 'update' and 'delete' operations. It also allows for multiple Java 'Classes' to map to the same 'Object Schema' produced by CocoButter(tm). Since CocoBase is built on the Java(tm) JDBC(tm) drivers from Javasoft, they require availability of JDBC drivers to your destination database to be available in order to function. There is currently driver availability for a JDBC/ODBC bridge on Wintel platforms, as well as IBM/DB2 drivers available from IBM as well as drivers from WebLogic for Oracle and Sybase on some platforms. Please contact your Database Vendor if you are unable to determine when and if a driver will available for your desired RDBMS.

A simple code fragment to demonstrate the simplicity of accessing an Object via the CocoPowder component is as follows:

// Instantiate a Customer Object setting the key field
Customer keyCust = new Customer("Customer Key Value");
// Select the customer object from the database
Customer foundCustomer = (Customer)myCocoPowderObj.select(keyCust);

The CocoMass(tm) - CocoButter(tm) Component:

CocoButter(tm) provides a simple, yet powerful separate applet based tool for the creation and administration of 'Object Schema' which are then stored in the relational database alongside the 'Relational Schema' and standard relational data. This tool internally creates all of the necessary SQL to access the database as part of the Object Schema creation. The tool provides a mechanism to centrally manage relational access SQL statements as well as to provide a convenient way to tune and modify them without the required involvement of an application programmer, or the recompile of application Code. Something as simple as a field name change can strike fear into traditional client/server environments, but with CocoButter(tm) application code and application programmers can be shielded completely from those changes!

The CocoBeans(tm) - Three Tier product add-on.

This three tier component can be introduced to a two-tier based CocoPowder application to give it a CORBA transport interface. It also has the necessary Java server side support for those orbs which support it. Code modifications are usually limited to a single line of code changing the instantiation of the CocoPowder(tm) object to a CocoNibs(tm) Object. Our intent is to support IIOP based CORBA implementations thereby providing support for all of the industry standard CORBA implementations for the Internet. Our first implementation also has planned support for JavaIDL and the Door Orb from Javasoft to allow organizations lightweight CORBA access through Java.

The CocoNibs(tm) - Three Tier product add-on.

This three tier component can also be introduced to a two-tier based CocoPowder application, and it gives the application an RMI interface between client and server. Code modifications are usually limited to a single line of code changing the instantiation of the CocoPowder(tm) object to a CocoNibs(tm) Object. The current implementation of RMI requires a JDK 1.02 runtime, therefore making it not useable on Netscape 2.x browsers. This solution is most suitable for use with an appletviewer or Java(tm) application.

Three-Tier Object Tunnelling.

One of the features of the CocoBase family which allows for rapid application development is a feature of creating a distributed Object interface without requiring Data Objects to be pre-compiled (often called IDL generated) as specifically three tier. Our interface Objects (CocoNibs(tm) and CocoBeans(tm)) have been IDL generated, and act as a 'tunnel' for retrieving Data Objects from the Server Database without requiring any modification to those Data Objects. This greatly simplifies the move to three tier, and limits the expertise required in order to build a three-tier application therefore bringing the power of CORBA to the masses without steep learning curves usually associated with such new technologies.

Three Tier Migration:

Migrating to a more flexible three-tier architecture is simple enough to be called trivial using the CocoBase(tm) add on products for Corba or RMI. We create an 'Object Tunnel' through CORBA/RMI or other transports we may support in the future, thereby allowing corporations to utilize a three tier architecture in simpler way than is currently available.

Product Benefits and features!

Reuse - Object Schema can be shared among applications:

This is a cornerstone premise of Object Oriented application development, and yet is often not realized by corporations. This can often be attributed to tool/language structures, which do not facilitate central repositories or code sharing.

So how is it that CocoBase facilitates sharing?

CocoBase provides a central repository of it's Object Schema which can be shared by all applications accessing the Database Instance. As a result, a change to an Object Schema in a Database will be immediately available to all applications using that Database.

Maintenance/Administration - Database Modification doesn't require recompile:

The traditional client server tools have left most of Corporate IS with less than optimum solutions when it comes to maintenance of more than the smallest of Client/Server infrastructures.

Unlike other tools which generate vast quantities of unmaintainable source code for Database Access, CocoBase(tm) creates an Object Schema which can be dynamically modified without recompiling any application! With a few clicks with the mouse, our administration program can be used to make Java(tm) Data Objects point to entirely new RDBMS fields, even from different or multiple RDBMS tables, without having to recode or even recompile Java(tm) Data Objects and applications. This provides an object 'Interface' to the database which can be dynamic enough to cope with relational and organizational changes.

The product is also revolutionary in that a single map can span multiple RDBMS Tables, not only for lookups (as a few products currently do), but also for updates, inserts and deletes. This functionality creates virtual updatable views even for the many databases which do not support them. A map can also be shared between multiple applications, so its update isn't just reflected in one application, but ALL applications which have used it. The cost savings from this feature alone can be monumental for an IS/IT organization!

It is also different from many other tools in that it allows for new Object types to be created to view existing/legacy databases without requiring rewiring of those databases to be useable. This virtual object layer can be applied to any database accessible through JDBC and can then be shared by all applications which access the database.

Simplicity:

- The programmer interfaces are trivial:

The Object Oriented programmer interfaces for Relational Access are extraordinarily simple. A template object must be instantiated which can be used to fill in the key values to be used during retrieval. That template is then passed to our CocoPowder layer where it is used to retrieve an object of the type requested. When the programmer receives the requested object, all fields are filled in with the values retrieved from the database.

// Instantiate a Customer Object setting the key field
Customer keyCust = new Customer("Customer Key Value");
// Select the customer object from the database
Customer foundCustomer = (Customer) myCocoPowderObj.select(keyCust <,optional Object-Schema Name>);

The Customer Object itself is only required to implement two simple APIs for getting and setting their persistable values.

- The overall development process has been simplified:

Development has been incredibly simplified by removing the need for Object Oriented application developers to also be experts at Databases, or for Database Programmers to be experts at Object Oriented. The two tasks have been decoupled, and once a repository of 'Corporate Views' has been created, Application Developers can use those views without ever even seeing any SQL or doing any SQL programming in the Database. And the programmer API has been significantly simplified to provide for more rapid development, and to allow the developer to concentrate on their application logic instead of worrying about details of database access in their application.

- The management of SQL access is simple:

Access is managed via a point and click interface, limiting typos and potential human errors. This management also allows for new Object Schema to be generated quickly and efficiently for existing relational tables.

- The migration from two-tier to three-tier is simple:

Unlike most two-tier to three-tier migration paths, CocoBase requires only a simple single line of code change in the client. The three-tier layer then manages access to through your transport layer (such as CORBA or RMI) transparently without requiring Data Object redefinition or recompile.

Separation of Skill Sets:

Skills for Java programming only requires an understand of the 'Object View' of data, SQL programming can be done independently by a Database Specialist with CocoButter(tm). Since SQL is administered separately via a GUI tool, the Java Application developer can work exclusively and more efficiently in an 'Object' paradigm, allowing people with the SQL expertise to deliver the data access in the most efficient and controlled manner.

Relational Flexibility:

Because CocoBase's GUI creates the necessary SQL to access the Database in a Dynamic way, we can present 'Logical Updatable Views' of the data even if an 'updatable' view is not possible with the particular RDBMS. Since the SQL is not embedded in the application, it can be modified to reflect (de)normalization of data and it's associated changes. The SQL can also be 'tuned' or field/table names modified by a Database Specialist without the required involvement of an application programmer and their valuable resources, and vice versa. This 'de-coupling' of the two models provides for a better focus on solving the specific problems associated with either application developers or Relational Database Specialists.

Deployment:

This product family can be deployed in a 1-2-3 tier scenario anywhere networking is available and the Java Virtual Machine and JDBC drivers exist. Every piece of code in this product family is written in Portable Java code, and will therefore be available everywhere, even Network Computers!

You thought it, made it! Give us your feedback, let us know how we're doing!